<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NoMvvm.TinyIoC</name>
    </assembly>
    <members>
        <member name="T:NoMvvm.TinyIoC.Constants">
            <summary>
            Class holding some static naming place holders for View/ViewModel
            </summary>
        </member>
        <member name="T:NoMvvm.TinyIoC.Adapter">
            <summary>
            An IAdapter wrapping a TinyIoC container for NoMvvm
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.#ctor(NoMvvm.TinyIoC.TinyIoCContainer)">
            <summary>
            Default ctor, requires a TinyIoCContainer
            </summary>
            <param name="container"></param>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.Get``1">
            <summary>
            Gets an exported value of type T
            </summary>
            <typeparam name="T"></typeparam>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.Get(System.String)">
            <summary>
            Gets an exported value by export name
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.GetMany``1">
            <summary>
            Gets a list of exported values of type T
            </summary>
            <typeparam name="T"></typeparam>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.GetMany(System.String)">
            <summary>
            Gets a list of exported values by export name
            NOTE: TinyIoC does not support this operation
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.GetView(System.String)">
            <summary>
            Gets a View of the specified name
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.GetViewModel(System.String)">
            <summary>
            Gets a ViewModel of the specified name
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.GetViewFor(System.Object)">
            <summary>
            Gets the View for specified ViewModel
            </summary>
            <param name="viewModel"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Adapter.AddView(System.String,System.Type,System.Type)">
            <summary>
            Registers a View/ViewModel pair with the TinyIoC container
            </summary>
            <param name="name"></param>
            <param name="viewType"></param>
            <param name="viewModelType"></param>
            <returns></returns>
        </member>
        <member name="T:NoMvvm.TinyIoC.Extensions">
            <summary>
            Holds extension methods for TinyIoC
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.Extensions.SetupTinyIoC(NoMvvm.Runtime,NoMvvm.TinyIoC.TinyIoCContainer)">
            <summary>
            Sets up the NoMvvm Runtime class with TinyIoC
            </summary>
            <param name="runtime"></param>
            <param name="container"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.Extensions.SetupTinyIoC(NoMvvm.Runtime,NoMvvm.TinyIoC.Adapter)">
            <summary>
            Sets up the NoMvvm Runtime class with TinyIoC
            </summary>
            <param name="runtime"></param>
            <param name="adapter"></param>
            <returns></returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TypeExtensions.GetGenericMethod(System.Type,System.Reflection.BindingFlags,System.String,System.Type[],System.Type[])">
            <summary>
            Gets a generic method from a type given the method name, binding flags, generic types and parameter types
            </summary>
            <param name="sourceType">Source type</param>
            <param name="bindingFlags">Binding flags</param>
            <param name="methodName">Name of the method</param>
            <param name="genericTypes">Generic types to use to make the method generic</param>
            <param name="parameterTypes">Method parameters</param>
            <returns>MethodInfo or null if no matches found</returns>
            <exception cref="T:System.Reflection.AmbiguousMatchException"/>
            <exception cref="T:System.ArgumentException"/>
        </member>
        <member name="T:NoMvvm.TinyIoC.NamedParameterOverloads">
            <summary>
            Name/Value pairs for specifying "user" parameters when resolving
            </summary>
        </member>
        <member name="F:NoMvvm.TinyIoC.UnregisteredResolutionActions.AttemptResolve">
            <summary>
            Attempt to resolve type, even if the type isn't registered.
            
            Registered types/options will always take precedence.
            </summary>
        </member>
        <member name="F:NoMvvm.TinyIoC.UnregisteredResolutionActions.Fail">
            <summary>
            Fail resolution if type not explicitly registered
            </summary>
        </member>
        <member name="F:NoMvvm.TinyIoC.UnregisteredResolutionActions.GenericsOnly">
            <summary>
            Attempt to resolve unregistered type if requested type is generic
            and no registration exists for the specific generic parameters used.
            
            Registered types/options will always take precedence.
            </summary>
        </member>
        <member name="T:NoMvvm.TinyIoC.ResolveOptions">
            <summary>
            Resolution settings
            </summary>
        </member>
        <member name="P:NoMvvm.TinyIoC.ResolveOptions.Default">
            <summary>
            Gets the default options (attempt resolution of unregistered types, fail on named resolution if name not found)
            </summary>
        </member>
        <member name="P:NoMvvm.TinyIoC.ResolveOptions.FailNameNotFoundOnly">
            <summary>
            Preconfigured option for attempting resolution of unregistered types and failing on named resolution if name not found
            </summary>
        </member>
        <member name="P:NoMvvm.TinyIoC.ResolveOptions.FailUnregisteredAndNameNotFound">
            <summary>
            Preconfigured option for failing on resolving unregistered types and on named resolution if name not found
            </summary>
        </member>
        <member name="P:NoMvvm.TinyIoC.ResolveOptions.FailUnregisteredOnly">
            <summary>
            Preconfigured option for failing on resolving unregistered types, but attempting unnamed resolution if name not found
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.AutoRegister">
            <summary>
            Attempt to automatically register all non-generic classes and interfaces in the current app domain.
            
            If more than one class implements an interface then only one implementation will be registered
            although no error will be thrown.
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.AutoRegister(System.Boolean)">
            <summary>
            Attempt to automatically register all non-generic classes and interfaces in the current app domain.
            </summary>
            <param name="ignoreDuplicateImplementations">Whether to ignore duplicate implementations of an interface/base class. False=throw an exception</param>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCAutoRegistrationException"/>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.AutoRegister(System.Reflection.Assembly)">
            <summary>
            Attempt to automatically register all non-generic classes and interfaces in the specified assembly
            
            If more than one class implements an interface then only one implementation will be registered
            although no error will be thrown.
            </summary>
            <param name="assembly">Assembly to process</param>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.AutoRegister(System.Reflection.Assembly,System.Boolean)">
            <summary>
            Attempt to automatically register all non-generic classes and interfaces in the specified assembly
            </summary>
            <param name="assembly">Assembly to process</param>
            <param name="ignoreDuplicateImplementations">Whether to ignore duplicate implementations of an interface/base class. False=throw an exception</param>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCAutoRegistrationException"/>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.AutoRegister(System.Collections.Generic.IEnumerable{System.Reflection.Assembly})">
            <summary>
            Attempt to automatically register all non-generic classes and interfaces in the specified assemblies
            
            If more than one class implements an interface then only one implementation will be registered
            although no error will be thrown.
            </summary>
            <param name="assemblies">Assemblies to process</param>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.AutoRegister(System.Collections.Generic.IEnumerable{System.Reflection.Assembly},System.Boolean)">
            <summary>
            Attempt to automatically register all non-generic classes and interfaces in the specified assemblies
            </summary>
            <param name="assemblies">Assemblies to process</param>
            <param name="ignoreDuplicateImplementations">Whether to ignore duplicate implementations of an interface/base class. False=throw an exception</param>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCAutoRegistrationException"/>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type)">
            <summary>
            Creates/replaces a container class registration with default options.
            </summary>
            <param name="registerImplementation">Type to register</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.String)">
            <summary>
            Creates/replaces a named container class registration with default options.
            </summary>
            <param name="registerImplementation">Type to register</param>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.Type)">
            <summary>
            Creates/replaces a container class registration with a given implementation and default options.
            </summary>
            <param name="registerType">Type to register</param>
            <param name="registerImplementation">Type to instantiate that implements RegisterType</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.Type,System.String)">
            <summary>
            Creates/replaces a named container class registration with a given implementation and default options.
            </summary>
            <param name="registerType">Type to register</param>
            <param name="registerImplementation">Type to instantiate that implements RegisterType</param>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.Object)">
            <summary>
            Creates/replaces a container class registration with a specific, strong referenced, instance.
            </summary>
            <param name="registerImplementation">Type to register</param>
            <param name="instance">Instance of RegisterType to register</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.Object,System.String)">
            <summary>
            Creates/replaces a named container class registration with a specific, strong referenced, instance.
            </summary>
            <param name="registerImplementation">Type to register</param>
            <param name="instance">Instance of RegisterType to register</param>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.Type,System.Object)">
            <summary>
            Creates/replaces a container class registration with a specific, strong referenced, instance.
            </summary>
            <param name="registerType">Type to register</param>
            <param name="registerImplementation">Type of instance to register that implements RegisterType</param>
            <param name="instance">Instance of RegisterImplementation to register</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register(System.Type,System.Type,System.Object,System.String)">
            <summary>
            Creates/replaces a named container class registration with a specific, strong referenced, instance.
            </summary>
            <param name="registerType">Type to register</param>
            <param name="registerImplementation">Type of instance to register that implements RegisterType</param>
            <param name="instance">Instance of RegisterImplementation to register</param>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``1">
            <summary>
            Creates/replaces a container class registration with default options.
            </summary>
            <typeparam name="RegisterImplementation">Type to register</typeparam>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``1(System.String)">
            <summary>
            Creates/replaces a named container class registration with default options.
            </summary>
            <typeparam name="RegisterImplementation">Type to register</typeparam>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``2">
            <summary>
            Creates/replaces a container class registration with a given implementation and default options.
            </summary>
            <typeparam name="RegisterType">Type to register</typeparam>
            <typeparam name="RegisterImplementation">Type to instantiate that implements RegisterType</typeparam>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``2(System.String)">
            <summary>
            Creates/replaces a named container class registration with a given implementation and default options.
            </summary>
            <typeparam name="RegisterType">Type to register</typeparam>
            <typeparam name="RegisterImplementation">Type to instantiate that implements RegisterType</typeparam>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``1(``0)">
            <summary>
            Creates/replaces a container class registration with a specific, strong referenced, instance.
            </summary>
            <typeparam name="RegisterImplementation">Type to register</typeparam>
            <param name="instance">Instance of RegisterType to register</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``1(``0,System.String)">
            <summary>
            Creates/replaces a named container class registration with a specific, strong referenced, instance.
            </summary>
            <typeparam name="RegisterImplementation">Type to register</typeparam>
            <param name="instance">Instance of RegisterType to register</param>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``2(``1)">
            <summary>
            Creates/replaces a container class registration with a specific, strong referenced, instance.
            </summary>
            <typeparam name="RegisterType">Type to register</typeparam>
            <typeparam name="RegisterImplementation">Type of instance to register that implements RegisterType</typeparam>
            <param name="instance">Instance of RegisterImplementation to register</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``2(``1,System.String)">
            <summary>
            Creates/replaces a named container class registration with a specific, strong referenced, instance.
            </summary>
            <typeparam name="RegisterType">Type to register</typeparam>
            <typeparam name="RegisterImplementation">Type of instance to register that implements RegisterType</typeparam>
            <param name="instance">Instance of RegisterImplementation to register</param>
            <param name="name">Name of registration</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``1(System.Func{NoMvvm.TinyIoC.TinyIoCContainer,NoMvvm.TinyIoC.NamedParameterOverloads,``0})">
            <summary>
            Creates/replaces a container class registration with a user specified factory
            </summary>
            <typeparam name="RegisterType">Type to register</typeparam>
            <param name="factory">Factory/lambda that returns an instance of RegisterType</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Register``1(System.Func{NoMvvm.TinyIoC.TinyIoCContainer,NoMvvm.TinyIoC.NamedParameterOverloads,``0},System.String)">
            <summary>
            Creates/replaces a named container class registration with a user specified factory
            </summary>
            <typeparam name="RegisterType">Type to register</typeparam>
            <param name="factory">Factory/lambda that returns an instance of RegisterType</param>
            <param name="name">Name of registation</param>
            <returns>RegisterOptions for fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterMultiple``1(System.Collections.Generic.IEnumerable{System.Type})">
            <summary>
            Register multiple implementations of a type.
            
            Internally this registers each implementation using the full name of the class as its registration name.
            </summary>
            <typeparam name="RegisterType">Type that each implementation implements</typeparam>
            <param name="implementationTypes">Types that implement RegisterType</param>
            <returns>MultiRegisterOptions for the fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterMultiple(System.Type,System.Collections.Generic.IEnumerable{System.Type})">
            <summary>
            Register multiple implementations of a type.
            
            Internally this registers each implementation using the full name of the class as its registration name.
            </summary>
            <param name="registrationType">Type that each implementation implements</param>
            <param name="implementationTypes">Types that implement RegisterType</param>
            <returns>MultiRegisterOptions for the fluent API</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type)">
            <summary>
            Attempts to resolve a type using default options.
            </summary>
            <param name="resolveType">Type to resolve</param>
            <returns>Instance of type</returns>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,NoMvvm.TinyIoC.ResolveOptions)">
            <summary>
            Attempts to resolve a type using specified options.
            </summary>
            <param name="resolveType">Type to resolve</param>
            <param name="options">Resolution options</param>
            <returns>Instance of type</returns>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,System.String)">
             <summary>
             Attempts to resolve a type using default options and the supplied name.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,System.String,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to resolve a type using supplied options and  name.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <param name="options">Resolution options</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to resolve a type using default options and the supplied constructor parameters.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="parameters">User specified constructor parameters</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to resolve a type using specified options and the supplied constructor parameters.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="parameters">User specified constructor parameters</param>
             <param name="options">Resolution options</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,System.String,NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to resolve a type using default options and the supplied constructor parameters and name.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="parameters">User specified constructor parameters</param>
             <param name="name">Name of registration</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve(System.Type,System.String,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to resolve a named type using specified options and the supplied constructor parameters.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <param name="parameters">User specified constructor parameters</param>
             <param name="options">Resolution options</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1">
            <summary>
            Attempts to resolve a type using default options.
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <returns>Instance of type</returns>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(NoMvvm.TinyIoC.ResolveOptions)">
            <summary>
            Attempts to resolve a type using specified options.
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="options">Resolution options</param>
            <returns>Instance of type</returns>
            <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(System.String)">
             <summary>
             Attempts to resolve a type using default options and the supplied name.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(System.String,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to resolve a type using supplied options and  name.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <param name="options">Resolution options</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to resolve a type using default options and the supplied constructor parameters.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="parameters">User specified constructor parameters</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to resolve a type using specified options and the supplied constructor parameters.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="parameters">User specified constructor parameters</param>
             <param name="options">Resolution options</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(System.String,NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to resolve a type using default options and the supplied constructor parameters and name.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="parameters">User specified constructor parameters</param>
             <param name="name">Name of registration</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.Resolve``1(System.String,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to resolve a named type using specified options and the supplied constructor parameters.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <param name="parameters">User specified constructor parameters</param>
             <param name="options">Resolution options</param>
             <returns>Instance of type</returns>
             <exception cref="T:NoMvvm.TinyIoC.TinyIoCResolutionException">Unable to resolve the type.</exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type)">
             <summary>
             Attempts to predict whether a given type can be resolved with default options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,System.String)">
             <summary>
             Attempts to predict whether a given named type can be resolved with default options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given type can be resolved with the specified options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,System.String,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given named type can be resolved with the specified options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to predict whether a given type can be resolved with the supplied constructor parameters and default options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="parameters">User supplied named parameter overloads</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,System.String,NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to predict whether a given named type can be resolved with the supplied constructor parameters and default options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <param name="parameters">User supplied named parameter overloads</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given type can be resolved with the supplied constructor parameters options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="parameters">User supplied named parameter overloads</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve(System.Type,System.String,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given named type can be resolved with the supplied constructor parameters options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <param name="resolveType">Type to resolve</param>
             <param name="name">Name of registration</param>
             <param name="parameters">User supplied named parameter overloads</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1">
             <summary>
             Attempts to predict whether a given type can be resolved with default options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(System.String)">
             <summary>
             Attempts to predict whether a given named type can be resolved with default options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given type can be resolved with the specified options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(System.String,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given named type can be resolved with the specified options.
            
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to predict whether a given type can be resolved with the supplied constructor parameters and default options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="parameters">User supplied named parameter overloads</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(System.String,NoMvvm.TinyIoC.NamedParameterOverloads)">
             <summary>
             Attempts to predict whether a given named type can be resolved with the supplied constructor parameters and default options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <param name="parameters">User supplied named parameter overloads</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given type can be resolved with the supplied constructor parameters options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="parameters">User supplied named parameter overloads</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.CanResolve``1(System.String,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
             <summary>
             Attempts to predict whether a given named type can be resolved with the supplied constructor parameters options.
            
             Parameters are used in conjunction with normal container resolution to find the most suitable constructor (if one exists).
             All user supplied parameters must exist in at least one resolvable constructor of RegisterType or resolution will fail.
             
             Note: Resolution may still fail if user defined factory registations fail to construct objects when called.
             </summary>
             <typeparam name="ResolveType">Type to resolve</typeparam>
             <param name="name">Name of registration</param>
             <param name="parameters">User supplied named parameter overloads</param>
             <param name="options">Resolution options</param>
             <returns>Bool indicating whether the type can be resolved</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,System.Object@)">
            <summary>
            Attemps to resolve a type using the default options
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,NoMvvm.TinyIoC.ResolveOptions,System.Object@)">
            <summary>
            Attemps to resolve a type using the given options
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,System.String,System.Object@)">
            <summary>
            Attemps to resolve a type using the default options and given name
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="name">Name of registration</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,System.String,NoMvvm.TinyIoC.ResolveOptions,System.Object@)">
            <summary>
            Attemps to resolve a type using the given options and name
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="name">Name of registration</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,NoMvvm.TinyIoC.NamedParameterOverloads,System.Object@)">
            <summary>
            Attemps to resolve a type using the default options and supplied constructor parameters
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,System.String,NoMvvm.TinyIoC.NamedParameterOverloads,System.Object@)">
            <summary>
            Attemps to resolve a type using the default options and supplied name and constructor parameters
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="name">Name of registration</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions,System.Object@)">
            <summary>
            Attemps to resolve a type using the supplied options and constructor parameters
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="name">Name of registration</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve(System.Type,System.String,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions,System.Object@)">
            <summary>
            Attemps to resolve a type using the supplied name, options and constructor parameters
            </summary>
            <param name="ResolveType">Type to resolve</param>
            <param name="name">Name of registration</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(``0@)">
            <summary>
            Attemps to resolve a type using the default options
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(NoMvvm.TinyIoC.ResolveOptions,``0@)">
            <summary>
            Attemps to resolve a type using the given options
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(System.String,``0@)">
            <summary>
            Attemps to resolve a type using the default options and given name
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="name">Name of registration</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(System.String,NoMvvm.TinyIoC.ResolveOptions,``0@)">
            <summary>
            Attemps to resolve a type using the given options and name
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="name">Name of registration</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(NoMvvm.TinyIoC.NamedParameterOverloads,``0@)">
            <summary>
            Attemps to resolve a type using the default options and supplied constructor parameters
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="parameters">User specified constructor parameters</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(System.String,NoMvvm.TinyIoC.NamedParameterOverloads,``0@)">
            <summary>
            Attemps to resolve a type using the default options and supplied name and constructor parameters
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="name">Name of registration</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions,``0@)">
            <summary>
            Attemps to resolve a type using the supplied options and constructor parameters
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="name">Name of registration</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.TryResolve``1(System.String,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions,``0@)">
            <summary>
            Attemps to resolve a type using the supplied name, options and constructor parameters
            </summary>
            <typeparam name="ResolveType">Type to resolve</typeparam>
            <param name="name">Name of registration</param>
            <param name="parameters">User specified constructor parameters</param>
            <param name="options">Resolution options</param>
            <param name="resolvedType">Resolved type or default if resolve fails</param>
            <returns>True if resolved sucessfully, false otherwise</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ResolveAll(System.Type,System.Boolean)">
            <summary>
            Returns all registrations of a type
            </summary>
            <param name="ResolveType">Type to resolveAll</param>
            <param name="includeUnnamed">Whether to include un-named (default) registrations</param>
            <returns>IEnumerable</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ResolveAll(System.Type)">
            <summary>
            Returns all registrations of a type, both named and unnamed
            </summary>
            <param name="ResolveType">Type to resolveAll</param>
            <returns>IEnumerable</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ResolveAll``1(System.Boolean)">
            <summary>
            Returns all registrations of a type
            </summary>
            <typeparam name="ResolveType">Type to resolveAll</typeparam>
            <param name="includeUnnamed">Whether to include un-named (default) registrations</param>
            <returns>IEnumerable</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ResolveAll``1">
            <summary>
            Returns all registrations of a type, both named and unnamed
            </summary>
            <typeparam name="ResolveType">Type to resolveAll</typeparam>
            <param name="includeUnnamed">Whether to include un-named (default) registrations</param>
            <returns>IEnumerable</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.BuildUp(System.Object)">
            <summary>
            Attempts to resolve all public property dependencies on the given object.
            </summary>
            <param name="input">Object to "build up"</param>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.BuildUp(System.Object,NoMvvm.TinyIoC.ResolveOptions)">
            <summary>
            Attempts to resolve all public property dependencies on the given object using the given resolve options.
            </summary>
            <param name="input">Object to "build up"</param>
            <param name="resolveOptions">Resolve options to use</param>
        </member>
        <member name="P:NoMvvm.TinyIoC.TinyIoCContainer.Current">
            <summary>
            Lazy created Singleton instance of the container for simple scenarios
            </summary>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions">
            <summary>
            Registration options for "fluent" API
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions.AsSingleton">
            <summary>
            Make registration a singleton (single instance) if possible
            </summary>
            <returns>RegisterOptions</returns>
            <exception cref="!:TinyIoCInstantiationTypeException"></exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions.AsMultiInstance">
            <summary>
            Make registration multi-instance if possible
            </summary>
            <returns>RegisterOptions</returns>
            <exception cref="!:TinyIoCInstantiationTypeException"></exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions.WithWeakReference">
            <summary>
            Make registration hold a weak reference if possible
            </summary>
            <returns>RegisterOptions</returns>
            <exception cref="!:TinyIoCInstantiationTypeException"></exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions.WithStrongReference">
            <summary>
            Make registration hold a strong reference if possible
            </summary>
            <returns>RegisterOptions</returns>
            <exception cref="!:TinyIoCInstantiationTypeException"></exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions.ToCustomLifetimeManager(NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions,NoMvvm.TinyIoC.TinyIoCContainer.ITinyIoCObjectLifetimeProvider,System.String)">
            <summary>
            Switches to a custom lifetime manager factory if possible.
            
            Usually used for RegisterOptions "To*" extension methods such as the ASP.Net per-request one.
            </summary>
            <param name="instance">RegisterOptions instance</param>
            <param name="lifetimeProvider">Custom lifetime manager</param>
            <param name="errorString">Error string to display if switch fails</param>
            <returns>RegisterOptions</returns>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.MultiRegisterOptions">
            <summary>
            Registration options for "fluent" API when registering multiple implementations
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.MultiRegisterOptions.#ctor(System.Collections.Generic.IEnumerable{NoMvvm.TinyIoC.TinyIoCContainer.RegisterOptions})">
            <summary>
            Initializes a new instance of the MultiRegisterOptions class.
            </summary>
            <param name="registerOptions">Registration options</param>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.MultiRegisterOptions.AsSingleton">
            <summary>
            Make registration a singleton (single instance) if possible
            </summary>
            <returns>RegisterOptions</returns>
            <exception cref="!:TinyIoCInstantiationTypeException"></exception>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.MultiRegisterOptions.AsMultiInstance">
            <summary>
            Make registration multi-instance if possible
            </summary>
            <returns>MultiRegisterOptions</returns>
            <exception cref="!:TinyIoCInstantiationTypeException"></exception>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.ITinyIoCObjectLifetimeProvider">
            <summary>
            Provides custom lifetime management for ASP.Net per-request lifetimes etc.
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ITinyIoCObjectLifetimeProvider.GetObject">
            <summary>
            Gets the stored object if it exists, or null if not
            </summary>
            <returns>Object instance or null</returns>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ITinyIoCObjectLifetimeProvider.SetObject(System.Object)">
            <summary>
            Store the object
            </summary>
            <param name="value">Object to store</param>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ITinyIoCObjectLifetimeProvider.ReleaseObject">
            <summary>
            Release the object
            </summary>
        </member>
        <member name="M:NoMvvm.TinyIoC.TinyIoCContainer.ObjectFactoryBase.GetObject(NoMvvm.TinyIoC.TinyIoCContainer,NoMvvm.TinyIoC.NamedParameterOverloads,NoMvvm.TinyIoC.ResolveOptions)">
            <summary>
            Create the type
            </summary>
            <param name="container">Container that requested the creation</param>
            <param name="parameters">Any user parameters passed</param>
            <returns></returns>
        </member>
        <member name="P:NoMvvm.TinyIoC.TinyIoCContainer.ObjectFactoryBase.AssumeConstruction">
            <summary>
            Whether to assume this factory sucessfully constructs its objects
            
            Generally set to true for delegate style factories as CanResolve cannot delve
            into the delegates they contain.
            </summary>
        </member>
        <member name="P:NoMvvm.TinyIoC.TinyIoCContainer.ObjectFactoryBase.CreatesType">
            <summary>
            The type the factory instantiates
            </summary>
        </member>
        <member name="P:NoMvvm.TinyIoC.TinyIoCContainer.ObjectFactoryBase.Constructor">
            <summary>
            Constructor to use, if specified
            </summary>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.MultiInstanceFactory`2">
            <summary>
            IObjectFactory that creates new instances of types for each resolution
            </summary>
            <typeparam name="RegisterType">Registered type</typeparam>
            <typeparam name="RegisterImplementation">Type to construct to fullful request for RegisteredType</typeparam>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.DelegateFactory`1">
            <summary>
            IObjectFactory that invokes a specified delegate to construct the object
            </summary>
            <typeparam name="RegisterType">Registered type to be constructed</typeparam>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.WeakDelegateFactory`1">
            <summary>
            IObjectFactory that invokes a specified delegate to construct the object
            
            Holds the delegate using a weak reference
            </summary>
            <typeparam name="RegisterType">Registered type to be constructed</typeparam>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.InstanceFactory`2">
            <summary>
            Stores an particular instance to return for a type
            </summary>
            <typeparam name="RegisterType">Registered type</typeparam>
            <typeparam name="RegisterImplementation">Type of the instance</typeparam>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.WeakInstanceFactory`2">
            <summary>
            Stores an particular instance to return for a type
            
            Stores the instance with a weak reference
            </summary>
            <typeparam name="RegisterType">Registered type</typeparam>
            <typeparam name="RegisterImplementation">Type of the instance</typeparam>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.SingletonFactory`2">
            <summary>
            A factory that lazy instantiates a type and always returns the same instance
            </summary>
            <typeparam name="RegisterType">Registered type</typeparam>
            <typeparam name="RegisterImplementation">Type to instantiate</typeparam>
        </member>
        <member name="T:NoMvvm.TinyIoC.TinyIoCContainer.CustomObjectLifetimeFactory`2">
            <summary>
            A factory that offloads lifetime to an external lifetime provider
            </summary>
            <typeparam name="RegisterType">Registered type</typeparam>
            <typeparam name="RegisterImplementation">Type to instantiate</typeparam>
        </member>
    </members>
</doc>
